/*
 * State_Machine.h
 *
 *  Created on: Oct 2, 2024
 *      Author: Grasping
 */
#ifndef MY_INC_APP_APP_ACLOAD_PFCSTATEMACHINE_H_
#define MY_INC_APP_APP_ACLOAD_PFCSTATEMACHINE_H_
#include "MY_INC/APP/APP_ACLoad_Protection.h"
#include "MY_INC/APP/APP_ACLoad_Pwm.h"
#include "MY_INC/APP/APP_Init.h"
#include "MY_INC/LC/LC_SYS.h"
#include "stdbool.h"

static inline void RunPFCLoop_State_ProcessControl(InterruptController *controller);

static inline void RunPFCLoop_State_Stop(InterruptController *controller);          // 停止状态处理
static inline void RunPFCLoop_State_Idle(InterruptController *controller);          // 空闲状态处理
static inline void RunPFCLoop_State_WaitLock(InterruptController *controller);      // 等待锁相状态处理
static inline void RunPFCLoop_State_WaitCrossZero(InterruptController *controller); // 等待过零点状态处理
static inline void RunPFCLoop_State_Running(InterruptController *controller);       // 运行状态处理
static inline void RunPFCLoop_State_Machine(InterruptController *controller);       // 状态机主控函数

static inline void RunPFCLoop_NoPLL_State_Machine(InterruptController *controller);
// static inline void RunPFCLoop_NoPLL_State_Stop(InterruptController *controller);
static inline void RunPFCLoop_NoPLL_State_Idle(InterruptController *controller);
static inline void RunPFCLoop_NoPLL_State_Running(InterruptController *controller);
static inline void RunPFCLoop_NoPLL_State_WaitCrossZero(InterruptController *controller);

static inline void RunPFCLoop_State_ProcessControl(InterruptController *Controller) // 修改为非事件激活
{
    /**********环路处理********************/
    RunPFCLoop_NoPLL_State_Machine(Controller); // 运行无PLL状态机
    SPWM_Control_Inline(&Controller->pwm);      // 传递整个 controller 和 PWM控制
}

/*==================================带锁相环状态机===================================*/
/*---------- 状态机主控函数 ----------*/
// 参数：系统指针，触发事件 (参数类型修正)
// 功能：根据当前状态调用对应的处理函数
static inline void RunPFCLoop_State_Machine(InterruptController *controller)
{
    // 新的 LoopStateMachine 结构体只有 current_state，直接根据它进行调度
    // 不再有 Last_State 和 Next_State 的显式管理，状态函数直接更新 current_state
    switch (controller->loop_sm.current_state) // 访问 loop_sm.current_state
    {
    case STATE_STOP:
        RunPFCLoop_State_Stop(controller); // 传递整个 controller
        break;
    case STATE_IDLE:
        RunPFCLoop_State_Idle(controller); // 传递整个 controller
        break;
    case STATE_WAIT_LOCK:                      // 枚举名称从 STATE_WAITLOCK 改为 STATE_WAIT_LOCK
        RunPFCLoop_State_WaitLock(controller); // 传递整个 controller
        break;
    case STATE_WAIT_CROSS_ZERO:                     // 枚举名称从 STATE_WAITCROSSZERO 改为 STATE_WAIT_CROSS_ZERO
        RunPFCLoop_State_WaitCrossZero(controller); // 传递整个 controller
        break;
    case STATE_RUN:                           // 枚举名称从 STATE_RUN 改为 STATE_RUN
        RunPFCLoop_State_Running(controller); // 传递整个 controller
        break;
    }
}

/*---------- 停止状态处理 ----------*/
// 参数类型修正，内部访问 loop_sm 和 param
static inline void RunPFCLoop_State_Stop(InterruptController *controller)
{
    switch (controller->loop_sm.event) // 访问 loop_sm.event
    {
    case EVENT_LOOP_NONE: // 无事件
        /*用户处理*/
        controller->pwm.pwm_en_flag = Nonactivated; // 不允许PWM
        Loop_Init(&controller->param);
        /*状态切换*/
        controller->loop_sm.current_state = STATE_IDLE; // 直接更新 current_state
        break;
    case EVENT_LOOP_STOP: // 停止事件
        /*用户处理*/
        controller->pwm.pwm_en_flag = Nonactivated; // 不允许PWM
        Loop_Init(&controller->param);              // 初始化环路参数
        /*状态切换*/
        controller->loop_sm.current_state = STATE_IDLE; // 直接更新 current_state
        break;
    default:                                            // 其他事件不响应
        controller->loop_sm.current_state = STATE_STOP; // 直接更新 current_state
        break;
    }
}
// 空闲状态处理 (参数类型修正，内部访问 loop_sm)
static inline void RunPFCLoop_State_Idle(InterruptController *controller)
{
    switch (controller->loop_sm.event) // 访问 loop_sm.event
    {
    case EVENT_LOOP_ENABLE: // 环路开始事件
        /*用户处理*/
        /*状态切换条件*/
        controller->loop_sm.current_state = STATE_WAIT_LOCK; // 直接更新 current_state
        break;
    case EVENT_LOOP_STOP: // 停止事件
        /*用户处理*/
        /*状态切换条件*/
        controller->loop_sm.current_state = STATE_STOP; // 直接更新 current_state
        break;
    case EVENT_LOOP_NONE: // 无事件
        /*用户处理*/
        /*状态切换*/
        controller->loop_sm.current_state = STATE_IDLE; // 直接更新 current_state
        break;
    default:                                            // 其他事件不响应
        controller->loop_sm.current_state = STATE_STOP; // 直接更新 current_state
        break;
    }
}

/*---------- 等待状态处理 ----------*/
#define LOCK_TIMEOUT 20000 // 10ms超时（假设100us中断）
// 等待锁相状态处理 (参数类型修正，内部访问 controller->param 和 controller->loop_sm)
static inline void RunPFCLoop_State_WaitLock(InterruptController *controller)
{
    switch (controller->loop_sm.event) // 访问 loop_sm.event
    {
    case EVENT_LOOP_STOP: // 环路失能事件
        /*用户处理*/
        /*状态切换*/
        controller->loop_sm.current_state = STATE_STOP; // 直接更新 current_state
        break;
    case EVENT_LOOP_NONE: // 无事件
        /*用户处理*/
        // 访问 controller->param.vg.actual
        TOGI_TO_DQ0_Inline(controller->param.togi_v, controller->param.vo_actual, controller->param.pll->W,
                           &controller->param.pll->Sine,
                           &controller->param.pll->Cosine); // 电压DQ变换
        PLL_Process_Inline(controller->param.pll, controller->param.togi_v->Q);

        // 访问 controller->param.lock_count
        if ((_isInRange(controller->param.togi_v->Q, -0.5f, 0.5f)) &&
            (_isInRange(controller->param.togi_v->D, 10.0f * Sqrt_2, 20.0f * Sqrt_2))) // DQ范围规定
        {
            if (controller->param.lock_count++ > 50) // 锁相计数器
            {
                controller->param.lock_timeout = 0;
                controller->param.lock_count = 0;                          // 锁相计数器清零
                controller->loop_sm.current_state = STATE_WAIT_CROSS_ZERO; // 直接更新 current_state
                break;
            }
        }
        else
        {
            controller->param.lock_count = 0; // 锁相计数器清零
        }
        // 超时处理 (访问 controller->param.lock_timeout)
        //        if (controller->param.lock_timeout++ > LOCK_TIMEOUT)
        //        {
        //            controller->loop_sm.current_state = STATE_STOP; // 直接更新 current_state
        //            controller->param.lock_timeout = 0;
        //            break;
        //        }
        controller->loop_sm.current_state = STATE_WAIT_LOCK; // 默认切换到等待锁相状态
        break;
    default:                                            // 其他事件不响应
        controller->loop_sm.current_state = STATE_STOP; // 直接更新 current_state
        break;
    }
}
// 等待过零点状态处理 (参数类型修正，内部访问 controller->param 和 controller->loop_sm)
static inline void RunPFCLoop_State_WaitCrossZero(InterruptController *controller)
{
    switch (controller->loop_sm.event) // 访问 loop_sm.event
    {
    case EVENT_LOOP_STOP: // 停止事件
        /*用户处理*/
        /*状态切换*/
        controller->loop_sm.current_state = STATE_STOP; // 直接更新 current_state
        break;
    case EVENT_LOOP_NONE: // 无事件
                          /*用户处理*/
        // 访问 controller->param.vg.actual
        TOGI_TO_DQ0_Inline(controller->param.togi_v, controller->param.vo_actual, controller->param.pll->W,
                           &controller->param.pll->Sine,
                           &controller->param.pll->Cosine); // 电压DQ变换
        PLL_Process_Inline(controller->param.pll, controller->param.togi_v->Q);
        if ((_isInRange(controller->param.togi_v->Q, -0.5f, 0.5f)) &&
            (_isInRange(controller->param.togi_v->D, 10.0f * Sqrt_2, 20.0f * Sqrt_2))) // DQ范围规定
        {
            if (controller->param.pll->Theta < 2.0f / 360.0f * _2PI)
            {
                // 这里需要设置PWM的初始状态，初始状态不对会炸机
                LL_HRTIM_TIM_SetCompare1(HRTIM1, controller->pwm.timer[0], 0);
                LL_HRTIM_TIM_SetCompare1(HRTIM1, controller->pwm.timer[1], 0);
                controller->loop_sm.current_state = STATE_RUN; // 直接更新 current_state
                break;
            }
        }
        else
        {
            controller->loop_sm.current_state = STATE_WAIT_LOCK; // 直接更新 current_state
            break;
        }
        /*默认转移判断*/
        controller->loop_sm.current_state = STATE_WAIT_CROSS_ZERO; // 默认切换到等待锁相状态
        break;
    default:                                            // 其他事件不响应
        controller->loop_sm.current_state = STATE_STOP; // 直接更新 current_state
        break;
    }
}

/*---------- 运行状态处理 ----------*/
// 运行状态处理 (参数类型修正，内部访问 controller->param 和 controller->loop_sm)
static inline void RunPFCLoop_State_Running(InterruptController *controller)
{
    switch (controller->loop_sm.event) // 访问 loop_sm.event
    {
    case EVENT_LOOP_STOP: // 停止事件
        /*用户处理*/
        controller->pwm.pwm_en_flag = Nonactivated; // 不允许PWM
        /*状态切换*/
        controller->loop_sm.current_state = STATE_STOP; // 直接更新 current_state
        break;
    case EVENT_LOOP_NONE: // 无事件
                          /*用户处理*/
        // 访问 controller->param.vg.actual
        TOGI_TO_DQ0_Inline(controller->param.togi_v, controller->param.vo_actual, controller->param.pll->W,
                           &controller->param.pll->Sine,
                           &controller->param.pll->Cosine); // 电压DQ变换
        PLL_Process_Inline(controller->param.pll, controller->param.togi_v->Q);
        // 访问 controller->param.il.ref
        /*状态转移判断*/
        if ((!_isInRange(controller->param.togi_v->Q, -0.5f, 0.5f)) |
            (!_isInRange(controller->param.togi_v->D, 10.0f * Sqrt_2, 20.0f * Sqrt_2))) // DQ范围规定
        {
            controller->pwm.pwm_en_flag = Nonactivated;          // 不允许PWM
            Loop_Init(&controller->param);                       // 初始化
            controller->loop_sm.current_state = STATE_WAIT_LOCK; // 直接更新 current_state
            break;
        }
        // 访问 controller->param.il.ref

        VariableStep_Update_Inline(controller->param.iref,
                                   controller->param.il_ref * _SQRT2 * 1.03f); // 访问 il.ref
        // , 1.0714285714是一个补偿，补偿输出电流未达到的部分，有电压环就不需要补偿
        controller->pwm.mod_wave = PMRdiff_Calculate_Inline(
            controller->param.pr_i, controller->param.iref->currentTemp * controller->param.pll->Sine,
            controller->param.il_actual);
        controller->pwm.pwm_en_flag = Activated; // 允许PWM
        /*默认转移*/
        controller->loop_sm.current_state = STATE_RUN; // 直接更新 current_state
        break;
    default:                                            // 其他事件不响应
        controller->loop_sm.current_state = STATE_STOP; // 直接更新 current_state
        break;
    }
}

static inline void RunPFCLoop_NoPLL_State_Machine(InterruptController *controller)
{
    switch (controller->loop_sm.current_state) // 访问 loop_sm.current_state
    {
    case STATE_IDLE:                             // 枚举名称从 STATE_WAITCROSSZERO 改为 STATE_WAIT_CROSS_ZERO
        RunPFCLoop_NoPLL_State_Idle(controller); // 传递整个 controller
        break;
    case STATE_WAIT_CROSS_ZERO:                           // 枚举名称从 STATE_WAITCROSSZERO 改为 STATE_WAIT_CROSS_ZERO
        RunPFCLoop_NoPLL_State_WaitCrossZero(controller); // 传递整个 controller
        break;
    case STATE_RUN:                                 // 枚举名称从 STATE_RUN 改为 STATE_RUN
        RunPFCLoop_NoPLL_State_Running(controller); // 传递整个 controller
        break;
    default: // 其他状态不处理

        break;
    }
}



/*---------- 停止状态处理 ----------*/
// 空闲状态处理 (参数类型修正，内部访问 loop_sm)
static inline void RunPFCLoop_NoPLL_State_Idle(InterruptController *controller)
{
    switch (controller->loop_sm.event) // 访问 loop_sm.event
    {
    case EVENT_LOOP_NONE:                               // 无事件
        controller->loop_sm.current_state = STATE_IDLE; // 直接更新 current_state
        break;
    default: // 其他事件不响应
    	controller->loop_sm.current_state = STATE_IDLE;
        break;
    }
}

// 等待过零点状态处理 (参数类型修正，内部访问 controller->param 和 controller->loop_sm)
static inline void RunPFCLoop_NoPLL_State_WaitCrossZero(InterruptController *controller)
{
    switch (controller->loop_sm.event) // 访问 loop_sm.event
    {
    case EVENT_LOOP_NONE:                         // 无事件
                                                  /*用户处理*/
        if ((controller->param.vo_actual < 0.5f)&& (controller->param.vo_actual > -0.5f)) // 有效值大于10V
        {
            LL_HRTIM_TIM_SetCompare1(HRTIM1, controller->pwm.timer[0], 0);
            LL_HRTIM_TIM_SetCompare1(HRTIM1, controller->pwm.timer[1], 0);
            // 这里需要设置PWM的初始状态，初始状态不对会炸机
            controller->loop_sm.current_state = STATE_RUN; // 直接更新 current_state
            break;
        }
        /*默认转移判断*/
        controller->loop_sm.current_state = STATE_WAIT_CROSS_ZERO; // 默认切换到等待锁相状态
        break;
    default: // 其他事件不响应
    	controller->loop_sm.current_state = STATE_IDLE;
        break;
    }
}

/*---------- 运行状态处理 ----------*/
// 运行状态处理 (参数类型修正，内部访问 controller->param 和 controller->loop_sm)
static inline void RunPFCLoop_NoPLL_State_Running(InterruptController *controller)
{
    switch (controller->loop_sm.event) // 访问 loop_sm.event
    {
    case EVENT_LOOP_NONE: // 无事件

    	VariableStep_Update_Inline(controller->param.udcref , controller->param.udc_ref);//放在这里软启动，可以不使用
        float temp = -AntiWindup_PID_Control_Inline(controller->param.pi_udc, controller->param.udc_ref,
                                                    controller->param.trap_udc->notch.Yn) *
                     (controller->param.vo_actual / controller->param.SignalAnalysisr_v->Vrms);

        controller->pwm.mod_wave =
            (PRdiff_Calculate_Inline(controller->param.pr_i[0], temp, controller->param.il_actual) +
             PRdiff_Calculate_Inline(controller->param.pr_i[1], temp, controller->param.il_actual) + // 主要处理三次谐波
             controller->param.vo_actual) /
            controller->param.trap_udc->notch.Yn;

        controller->pwm.pwm_en_flag = Activated; // 允许PWM
        /*默认转移*/
        controller->loop_sm.current_state = STATE_RUN; // 直接更新 current_state
        break;
    default: // 其他事件不响应
    	controller->loop_sm.current_state = STATE_IDLE;
        break;
    }
}

/*以下函数成功运行*/
// static inline void RunPFCLoop_NoPLL_State_Machine(InterruptController *controller)
// {
//     // 新的 LoopStateMachine 结构体只有 current_state，直接根据它进行调度
//     // 不再有 Last_State 和 Next_State 的显式管理，状态函数直接更新 current_state
//     switch (controller->loop_sm.current_state) // 访问 loop_sm.current_state
//     {
//     case STATE_STOP:
//         RunPFCLoop_NoPLL_State_Stop(controller); // 传递整个 controller
//         break;
//     case STATE_IDLE:
//         RunPFCLoop_NoPLL_State_Idle(controller); // 传递整个 controller
//         break;
//     case STATE_WAIT_CROSS_ZERO:                           // 枚举名称从 STATE_WAITCROSSZERO 改为
//     STATE_WAIT_CROSS_ZERO
//         RunPFCLoop_NoPLL_State_WaitCrossZero(controller); // 传递整个 controller
//         break;
//     case STATE_RUN:                                 // 枚举名称从 STATE_RUN 改为 STATE_RUN
//         RunPFCLoop_NoPLL_State_Running(controller); // 传递整个 controller
//         break;
//     default:                                            // 其他状态不处理
//         controller->loop_sm.current_state = STATE_STOP; // 直接更新 current_state
//         break;
//     }
// }

// /*---------- 停止状态处理 ----------*/
// // 参数类型修正，内部访问 loop_sm 和 param
// static inline void RunPFCLoop_NoPLL_State_Stop(InterruptController *controller)
// {
//     switch (controller->loop_sm.event) // 访问 loop_sm.event
//     {
//     case EVENT_LOOP_NONE: // 无事件
//         /*用户处理*/
//         controller->pwm.pwm_en_flag = Nonactivated; // 不允许PWM
//         Loop_Init(&controller->param);
//         /*状态切换*/
//         controller->loop_sm.current_state = STATE_IDLE; // 直接更新 current_state
//         break;
//     case EVENT_LOOP_STOP: // 停止事件
//         /*用户处理*/
//         controller->pwm.pwm_en_flag = Nonactivated; // 不允许PWM
//         Loop_Init(&controller->param);              // 初始化环路参数
//         /*状态切换*/
//         controller->loop_sm.current_state = STATE_IDLE; // 直接更新 current_state
//         break;
//     default:                                            // 其他事件不响应
//         controller->loop_sm.current_state = STATE_STOP; // 直接更新 current_state
//         break;
//     }
// }
// // 空闲状态处理 (参数类型修正，内部访问 loop_sm)
// static inline void RunPFCLoop_NoPLL_State_Idle(InterruptController *controller)
// {
//     switch (controller->loop_sm.event) // 访问 loop_sm.event
//     {
//     case EVENT_LOOP_ENABLE: // 环路开始事件
//         /*用户处理*/
//         /*状态切换条件*/
//         controller->loop_sm.current_state = STATE_WAIT_CROSS_ZERO; // 直接更新 current_state
//         break;
//     case EVENT_LOOP_STOP: // 停止事件
//         /*用户处理*/
//         /*状态切换条件*/
//         controller->loop_sm.current_state = STATE_STOP; // 直接更新 current_state
//         break;
//     case EVENT_LOOP_NONE: // 无事件
//         /*用户处理*/
//         /*状态切换*/
//         controller->loop_sm.current_state = STATE_IDLE; // 直接更新 current_state
//         break;
//     default:                                            // 其他事件不响应
//         controller->loop_sm.current_state = STATE_STOP; // 直接更新 current_state
//         break;
//     }
// }

// // 等待过零点状态处理 (参数类型修正，内部访问 controller->param 和 controller->loop_sm)
// static inline void RunPFCLoop_NoPLL_State_WaitCrossZero(InterruptController *controller)
// {
//     switch (controller->loop_sm.event) // 访问 loop_sm.event
//     {
//     case EVENT_LOOP_STOP: // 停止事件
//         /*用户处理*/
//         /*状态切换*/
//         controller->loop_sm.current_state = STATE_STOP; // 直接更新 current_state
//         break;
//     case EVENT_LOOP_NONE:                                    // 无事件
//                                                              /*用户处理*/
//         if (controller->param.SignalAnalysisr->Vrms > 12.0f) // 有效值大于10V
//         {
//             if (controller->param.vo_actual < 0.5f)
//             {
//                 LL_HRTIM_TIM_SetCompare1(HRTIM1, controller->pwm.timer[0], 0);
//                 LL_HRTIM_TIM_SetCompare1(HRTIM1, controller->pwm.timer[1], 0);
//                 // 这里需要设置PWM的初始状态，初始状态不对会炸机
//                 controller->loop_sm.current_state = STATE_RUN; // 直接更新 current_state
//                 break;
//             }
//         }
//         else // 有效值不满足
//         {
//             controller->loop_sm.current_state = STATE_STOP; // 返回
//             break;
//         }
//         /*默认转移判断*/
//         controller->loop_sm.current_state = STATE_WAIT_CROSS_ZERO; // 默认切换到等待锁相状态
//         break;
//     default:                                            // 其他事件不响应
//         controller->loop_sm.current_state = STATE_STOP; // 直接更新 current_state
//         break;
//     }
// }

// /*---------- 运行状态处理 ----------*/
// // 运行状态处理 (参数类型修正，内部访问 controller->param 和 controller->loop_sm)
// static inline void RunPFCLoop_NoPLL_State_Running(InterruptController *controller)
// {
//     switch (controller->loop_sm.event) // 访问 loop_sm.event
//     {
//     case EVENT_LOOP_STOP: // 停止事件
//         /*用户处理*/
//         controller->pwm.pwm_en_flag = Nonactivated; // 不允许PWM
//         /*状态切换*/
//         controller->loop_sm.current_state = STATE_STOP; // 直接更新 current_state
//         break;
//     case EVENT_LOOP_NONE: // 无事件
//                           /*用户处理*/
//         // if (controller->param.SignalAnalysisr->Vrms < 12.0f) // DQ范围规定
//         // {
//         //     controller->pwm.pwm_en_flag = Nonactivated;     // 不允许PWM
//         //     Loop_Init(&controller->param);                  // 初始化
//         //     controller->loop_sm.current_state = STATE_STOP; // 返回空闲状态
//         //     break;
//         // }

//         //
//         变步长还是有用的，优点：在你强制电流换向时提供过度点，防止变化过快炸机，缺点：会在启动时存在一个小的电流跌落
//         // 这里PI要加个负号
//         VariableStep_Update_Inline(controller->param.udcref, controller->param.udc_ref);
//         float temp = -Increasing_PI_Control_Inline(controller->param.pi_udc, controller->param.udc_ref,
//                                                    controller->param.trap_udc->notch.Yn) *
//                      (controller->param.SignalAnalysisr->phaseshifter_output /
//                      controller->param.SignalAnalysisr->Vrms);
//         // 计算PWM调制波形  ,如果使用前馈记得把PR计算的1.0f限幅去掉
//         controller->pwm.mod_wave =
//             (PRdiff_Calculate_Inline(controller->param.pr_i[0], temp, controller->param.il_actual) +
//              controller->param.vo_actual) /
//             controller->param.trap_udc->notch.Yn;

//         controller->pwm.pwm_en_flag = Activated; // 允许PWM
//         /*默认转移*/
//         controller->loop_sm.current_state = STATE_RUN; // 直接更新 current_state
//         break;
//     default:                                            // 其他事件不响应
//         controller->loop_sm.current_state = STATE_STOP; // 直接更新 current_state
//         break;
//


//
//void RunPFCLoop_State_ProcessControl(InterruptController *Controller) // 修改为非事件激活
//{
//    /**********环路处理********************/
//    RunPFCLoop_NoPLL_State_Machine(Controller); // 运行无PLL状态机
//    SPWM_Control_Inline(&Controller->pwm);      // 传递整个 controller 和 PWM控制
//}
//static inline void RunPFCLoop_State_ProcessControl(InterruptController *Controller) // 修改为非事件激活
//{
//    /**********环路处理********************/
//    RunPFCLoop_NoPLL_State_Machine(Controller); // 运行无PLL状态机
//    SPWM_Control_Inline(&Controller->pwm);      // 传递整个 controller 和 PWM控制
//}
// static inline void RunPFCLoop_State_ProcessControl(InterruptController *Controller)
// {
//     // 对传入的指针进行空值检查，这是一个好的编程习惯
//     if (Controller == NULL)
//     {
//         // 可以在这里添加错误处理，例如日志记录或返回错误码
//         Uart1_Printf("Error: Control is NULL in ProcessControl.\n");
//         return;
//     }
//     /**********环路处理********************/
//     Trap_Filter_Inline(Controller->param.trap_udc, Controller->param.udc_actual); // 滤波处理
//     // 根据设备的当前状态进行不同的处理
//     switch (Controller->monitor.device_state)
//     {
//     case DEVICE_STATE_NORMAL:
//         // 正常状态下，默认事件为无事件
//         Controller->loop_sm.event = EVENT_LOOP_NONE;

//         // 如果启动标志被激活
//         if (Controller->loop_sm.start_flag == Activated)
//         {
//             Controller->loop_sm.event = EVENT_LOOP_ENABLE; // 设置为使能事件
//             Controller->loop_sm.start_flag = Nonactivated; // 清除启动标志
//         }
//         // 如果停止标志被激活
//         if (Controller->loop_sm.stop_flag == Activated)
//         {
//             Controller->loop_sm.event = EVENT_LOOP_STOP;  // 设置为停止事件
//             Controller->loop_sm.stop_flag = Nonactivated; // 清除停止标志
//             Controller->param.il_ref = 0.0f;              // 将参考电流设为0
//         }
//         break;

//     case DEVICE_STATE_FAULT: // 设备处于故障状态
//         // 故障状态下，清除启动标志，默认事件为无事件
//         Controller->loop_sm.start_flag = Nonactivated;
//         Controller->loop_sm.event = EVENT_LOOP_NONE;

//         // 如果停止标志被激活 (即便在故障状态下，停止指令也应被响应)
//         if (Controller->loop_sm.stop_flag == Activated)
//         {
//             Controller->loop_sm.event = EVENT_LOOP_STOP;  // 设置为停止事件
//             Controller->loop_sm.stop_flag = Nonactivated; // 清除停止标志
//             Controller->param.il_ref = 0.0f;              // 将参考电流设为0
//         }
//         break;

//     case DEVICE_STATE_HALT: // 设备处于暂停/停止状态
//         // 暂停状态下，清除启动和停止标志，强制设置为停止事件
//         Controller->loop_sm.start_flag = Nonactivated;
//         Controller->loop_sm.stop_flag = Nonactivated;
//         Controller->loop_sm.event = EVENT_LOOP_STOP;
//         break;

//     default:
//         // 处理未预期的设备状态，可添加日志或默认行为
//         break;
//     } // Test_Mode == 0
//     // RunPFCLoop_State_Machine(Controller); // 运行电网环状态机
//     RunPFCLoop_NoPLL_State_Machine(Controller); // 运行无PLL状态机
//     SPWM_Control_Inline(&Controller->pwm);      // 传递整个 controller 和 PWM控制
// }
/*==================================带锁相环状态机===================================*/
/*---------- 状态机主控函数 ----------*/
// 参数：系统指针，触发事件 (参数类型修正)
// 功能：根据当前状态调用对应的处理函数
//static inline void RunPFCLoop_State_Machine(InterruptController *controller)
//{
//    // 新的 LoopStateMachine 结构体只有 current_state，直接根据它进行调度
//    // 不再有 Last_State 和 Next_State 的显式管理，状态函数直接更新 current_state
//    switch (controller->loop_sm.current_state) // 访问 loop_sm.current_state
//    {
//    case STATE_STOP:
//        RunPFCLoop_State_Stop(controller); // 传递整个 controller
//        break;
//    case STATE_IDLE:
//        RunPFCLoop_State_Idle(controller); // 传递整个 controller
//        break;
//    case STATE_WAIT_LOCK:                      // 枚举名称从 STATE_WAITLOCK 改为 STATE_WAIT_LOCK
//        RunPFCLoop_State_WaitLock(controller); // 传递整个 controller
//        break;
//    case STATE_WAIT_CROSS_ZERO:                     // 枚举名称从 STATE_WAITCROSSZERO 改为 STATE_WAIT_CROSS_ZERO
//        RunPFCLoop_State_WaitCrossZero(controller); // 传递整个 controller
//        break;
//    case STATE_RUN:                           // 枚举名称从 STATE_RUN 改为 STATE_RUN
//        RunPFCLoop_State_Running(controller); // 传递整个 controller
//        break;
//    }
//}
//
///*---------- 停止状态处理 ----------*/
//// 参数类型修正，内部访问 loop_sm 和 param
//static inline void RunPFCLoop_State_Stop(InterruptController *controller)
//{
//    switch (controller->loop_sm.event) // 访问 loop_sm.event
//    {
//    case EVENT_LOOP_NONE: // 无事件
//        /*用户处理*/
//        controller->pwm.pwm_en_flag = Nonactivated; // 不允许PWM
//        Loop_Init(&controller->param);
//        /*状态切换*/
//        controller->loop_sm.current_state = STATE_IDLE; // 直接更新 current_state
//        break;
//    case EVENT_LOOP_STOP: // 停止事件
//        /*用户处理*/
//        controller->pwm.pwm_en_flag = Nonactivated; // 不允许PWM
//        Loop_Init(&controller->param);              // 初始化环路参数
//        /*状态切换*/
//        controller->loop_sm.current_state = STATE_IDLE; // 直接更新 current_state
//        break;
//    default:                                            // 其他事件不响应
//        controller->loop_sm.current_state = STATE_STOP; // 直接更新 current_state
//        break;
//    }
//}
//// 空闲状态处理 (参数类型修正，内部访问 loop_sm)
//static inline void RunPFCLoop_State_Idle(InterruptController *controller)
//{
//    switch (controller->loop_sm.event) // 访问 loop_sm.event
//    {
//    case EVENT_LOOP_ENABLE: // 环路开始事件
//        /*用户处理*/
//        /*状态切换条件*/
//        controller->loop_sm.current_state = STATE_WAIT_LOCK; // 直接更新 current_state
//        break;
//    case EVENT_LOOP_STOP: // 停止事件
//        /*用户处理*/
//        /*状态切换条件*/
//        controller->loop_sm.current_state = STATE_STOP; // 直接更新 current_state
//        break;
//    case EVENT_LOOP_NONE: // 无事件
//        /*用户处理*/
//        /*状态切换*/
//        controller->loop_sm.current_state = STATE_IDLE; // 直接更新 current_state
//        break;
//    default:                                            // 其他事件不响应
//        controller->loop_sm.current_state = STATE_STOP; // 直接更新 current_state
//        break;
//    }
//}
//
///*---------- 等待状态处理 ----------*/
//#define LOCK_TIMEOUT 20000 // 10ms超时（假设100us中断）
//// 等待锁相状态处理 (参数类型修正，内部访问 controller->param 和 controller->loop_sm)
//static inline void RunPFCLoop_State_WaitLock(InterruptController *controller)
//{
//    switch (controller->loop_sm.event) // 访问 loop_sm.event
//    {
//    case EVENT_LOOP_STOP: // 环路失能事件
//        /*用户处理*/
//        /*状态切换*/
//        controller->loop_sm.current_state = STATE_STOP; // 直接更新 current_state
//        break;
//    case EVENT_LOOP_NONE: // 无事件
//        /*用户处理*/
//        // 访问 controller->param.vg.actual
//        TOGI_TO_DQ0_Inline(controller->param.togi_v, controller->param.vo_actual, controller->param.pll->W,
//                           &controller->param.pll->Sine,
//                           &controller->param.pll->Cosine); // 电压DQ变换
//        PLL_Process_Inline(controller->param.pll, controller->param.togi_v->Q);
//
//        // 访问 controller->param.lock_count
//        if ((_isInRange(controller->param.togi_v->Q, -0.5f, 0.5f)) &&
//            (_isInRange(controller->param.togi_v->D, 10.0f * Sqrt_2, 20.0f * Sqrt_2))) // DQ范围规定
//        {
//            if (controller->param.lock_count++ > 50) // 锁相计数器
//            {
//                controller->param.lock_timeout = 0;
//                controller->param.lock_count = 0;                          // 锁相计数器清零
//                controller->loop_sm.current_state = STATE_WAIT_CROSS_ZERO; // 直接更新 current_state
//                break;
//            }
//        }
//        else
//        {
//            controller->param.lock_count = 0; // 锁相计数器清零
//        }
//        // 超时处理 (访问 controller->param.lock_timeout)
//        //        if (controller->param.lock_timeout++ > LOCK_TIMEOUT)
//        //        {
//        //            controller->loop_sm.current_state = STATE_STOP; // 直接更新 current_state
//        //            controller->param.lock_timeout = 0;
//        //            break;
//        //        }
//        controller->loop_sm.current_state = STATE_WAIT_LOCK; // 默认切换到等待锁相状态
//        break;
//    default:                                            // 其他事件不响应
//        controller->loop_sm.current_state = STATE_STOP; // 直接更新 current_state
//        break;
//    }
//}
//// 等待过零点状态处理 (参数类型修正，内部访问 controller->param 和 controller->loop_sm)
//static inline void RunPFCLoop_State_WaitCrossZero(InterruptController *controller)
//{
//    switch (controller->loop_sm.event) // 访问 loop_sm.event
//    {
//    case EVENT_LOOP_STOP: // 停止事件
//        /*用户处理*/
//        /*状态切换*/
//        controller->loop_sm.current_state = STATE_STOP; // 直接更新 current_state
//        break;
//    case EVENT_LOOP_NONE: // 无事件
//                          /*用户处理*/
//        // 访问 controller->param.vg.actual
//        TOGI_TO_DQ0_Inline(controller->param.togi_v, controller->param.vo_actual, controller->param.pll->W,
//                           &controller->param.pll->Sine,
//                           &controller->param.pll->Cosine); // 电压DQ变换
//        PLL_Process_Inline(controller->param.pll, controller->param.togi_v->Q);
//        if ((_isInRange(controller->param.togi_v->Q, -0.5f, 0.5f)) &&
//            (_isInRange(controller->param.togi_v->D, 10.0f * Sqrt_2, 20.0f * Sqrt_2))) // DQ范围规定
//        {
//            if (controller->param.pll->Theta < 2.0f / 360.0f * _2PI)
//            {
//                //                Pwm_Enable(&controller->pwm); // 使能PWM
//                // 这里需要设置PWM的初始状态，初始状态不对会炸机
//                LL_HRTIM_TIM_SetCompare1(HRTIM1, controller->pwm.timer[0], 0);
//                LL_HRTIM_TIM_SetCompare1(HRTIM1, controller->pwm.timer[1], 0);
//                //                LL_HRTIM_EnableOutput(HRTIM1, controller->pwm.output_p[0] |
//                //                controller->pwm.output_n[0] |
//                //                                                  controller->pwm.output_p[1] |
//                //                                                  controller->pwm.output_n[1]);
//                controller->loop_sm.current_state = STATE_RUN; // 直接更新 current_state
//                break;
//            }
//        }
//        else
//        {
//            controller->loop_sm.current_state = STATE_WAIT_LOCK; // 直接更新 current_state
//            break;
//        }
//        /*默认转移判断*/
//        controller->loop_sm.current_state = STATE_WAIT_CROSS_ZERO; // 默认切换到等待锁相状态
//        break;
//    default:                                            // 其他事件不响应
//        controller->loop_sm.current_state = STATE_STOP; // 直接更新 current_state
//        break;
//    }
//}
//
///*---------- 运行状态处理 ----------*/
//// 运行状态处理 (参数类型修正，内部访问 controller->param 和 controller->loop_sm)
//static inline void RunPFCLoop_State_Running(InterruptController *controller)
//{
//    switch (controller->loop_sm.event) // 访问 loop_sm.event
//    {
//    case EVENT_LOOP_STOP: // 停止事件
//        /*用户处理*/
//        controller->pwm.pwm_en_flag = Nonactivated; // 不允许PWM
//        /*状态切换*/
//        controller->loop_sm.current_state = STATE_STOP; // 直接更新 current_state
//        break;
//    case EVENT_LOOP_NONE: // 无事件
//                          /*用户处理*/
//        // 访问 controller->param.vg.actual
//        TOGI_TO_DQ0_Inline(controller->param.togi_v, controller->param.vo_actual, controller->param.pll->W,
//                           &controller->param.pll->Sine,
//                           &controller->param.pll->Cosine); // 电压DQ变换
//        PLL_Process_Inline(controller->param.pll, controller->param.togi_v->Q);
//        // 访问 controller->param.il.ref
//        /*状态转移判断*/
//        if ((!_isInRange(controller->param.togi_v->Q, -0.5f, 0.5f)) |
//            (!_isInRange(controller->param.togi_v->D, 10.0f * Sqrt_2, 20.0f * Sqrt_2))) // DQ范围规定
//        {
//            controller->pwm.pwm_en_flag = Nonactivated;          // 不允许PWM
//            Loop_Init(&controller->param);                       // 初始化
//            controller->loop_sm.current_state = STATE_WAIT_LOCK; // 直接更新 current_state
//            break;
//        }
//        // 访问 controller->param.il.ref
//
//        VariableStep_Update_Inline(controller->param.iref,
//                                   controller->param.il_ref * _SQRT2 * 1.03f); // 访问 il.ref
//        // , 1.0714285714是一个补偿，补偿输出电流未达到的部分，有电压环就不需要补偿
//        controller->pwm.mod_wave = PMRdiff_Calculate_Inline(
//            controller->param.pr_i, controller->param.iref->currentTemp * controller->param.pll->Sine,
//            controller->param.il_actual);
//        controller->pwm.pwm_en_flag = Activated; // 允许PWM
//        /*默认转移*/
//        controller->loop_sm.current_state = STATE_RUN; // 直接更新 current_state
//        break;
//    default:                                            // 其他事件不响应
//        controller->loop_sm.current_state = STATE_STOP; // 直接更新 current_state
//        break;
//    }
//}
//
//static inline void RunPFCLoop_NoPLL_State_Machine(InterruptController *controller)
//{
//    switch (controller->loop_sm.current_state) // 访问 loop_sm.current_state
//    {
//    case STATE_IDLE:                             // 枚举名称从 STATE_WAITCROSSZERO 改为 STATE_WAIT_CROSS_ZERO
//        RunPFCLoop_NoPLL_State_Idle(controller); // 传递整个 controller
//        break;
//    case STATE_WAIT_CROSS_ZERO:                           // 枚举名称从 STATE_WAITCROSSZERO 改为 STATE_WAIT_CROSS_ZERO
//        RunPFCLoop_NoPLL_State_WaitCrossZero(controller); // 传递整个 controller
//        break;
//    case STATE_RUN:                                 // 枚举名称从 STATE_RUN 改为 STATE_RUN
//        RunPFCLoop_NoPLL_State_Running(controller); // 传递整个 controller
//        break;
//    default: // 其他状态不处理
//
//        break;
//    }
//}
//
///*---------- 停止状态处理 ----------*/
//
//// 空闲状态处理 (参数类型修正，内部访问 loop_sm)
//static inline void RunPFCLoop_NoPLL_State_Idle(InterruptController *controller)
//{
//    switch (controller->loop_sm.event) // 访问 loop_sm.event
//    {
//    case EVENT_LOOP_NONE:                               // 无事件
//        controller->loop_sm.current_state = STATE_IDLE; // 直接更新 current_state
//        break;
//    default: // 其他事件不响应
//        break;
//    }
//}
//
//// 等待过零点状态处理 (参数类型修正，内部访问 controller->param 和 controller->loop_sm)
//static inline void RunPFCLoop_NoPLL_State_WaitCrossZero(InterruptController *controller)
//{
//    switch (controller->loop_sm.event) // 访问 loop_sm.event
//    {
//    case EVENT_LOOP_NONE:                         // 无事件
//                                                  /*用户处理*/
//        if ((controller->param.vo_actual < 0.5f)) // 有效值大于10V
//        {
//            LL_HRTIM_TIM_SetCompare1(HRTIM1, controller->pwm.timer[0], 0);
//            LL_HRTIM_TIM_SetCompare1(HRTIM1, controller->pwm.timer[1], 0);
//            // 这里需要设置PWM的初始状态，初始状态不对会炸机
//            controller->loop_sm.current_state = STATE_RUN; // 直接更新 current_state
//            break;
//        }
//        /*默认转移判断*/
//        controller->loop_sm.current_state = STATE_WAIT_CROSS_ZERO; // 默认切换到等待锁相状态
//        break;
//    default: // 其他事件不响应
//        break;
//    }
//}
//
///*---------- 运行状态处理 ----------*/
//// 运行状态处理 (参数类型修正，内部访问 controller->param 和 controller->loop_sm)
//static inline void RunPFCLoop_NoPLL_State_Running(InterruptController *controller)
//{
//    switch (controller->loop_sm.event) // 访问 loop_sm.event
//    {
//    case EVENT_LOOP_NONE: // 无事件
//        VariableStep_Update_Inline(controller->param.udcref, controller->param.udc_ref);
//        float temp = -AntiWindup_PID_Control_Inline(controller->param.pi_udc, controller->param.udcref->currentTemp,
//                                                    controller->param.trap_udc->notch.Yn) *
//                     (controller->param.SignalAnalysisr->phaseshifter_output / controller->param.SignalAnalysisr->Vrms);
//
//        // 计算PWM调制波形  ,如果使用前馈记得把PR计算的1.0f限幅去掉
//        controller->pwm.mod_wave =
//            (PRdiff_Calculate_Inline(controller->param.pr_i[0], temp, controller->param.il_actual) +
//             PRdiff_Calculate_Inline(controller->param.pr_i[1], temp, controller->param.il_actual) + // 主要处理三次谐波
//             controller->param.vo_actual) /
//            controller->param.trap_udc->notch.Yn;
//        controller->pwm.pwm_en_flag = Activated; // 允许PWM
//        /*默认转移*/
//        controller->loop_sm.current_state = STATE_RUN; // 直接更新 current_state
//        break;
//    default: // 其他事件不响应
//        break;
//    }
//}

/*以下函数成功运行*/
// static inline void RunPFCLoop_NoPLL_State_Machine(InterruptController *controller)
// {
//     // 新的 LoopStateMachine 结构体只有 current_state，直接根据它进行调度
//     // 不再有 Last_State 和 Next_State 的显式管理，状态函数直接更新 current_state
//     switch (controller->loop_sm.current_state) // 访问 loop_sm.current_state
//     {
//     case STATE_STOP:
//         RunPFCLoop_NoPLL_State_Stop(controller); // 传递整个 controller
//         break;
//     case STATE_IDLE:
//         RunPFCLoop_NoPLL_State_Idle(controller); // 传递整个 controller
//         break;
//     case STATE_WAIT_CROSS_ZERO:                           // 枚举名称从 STATE_WAITCROSSZERO 改为
//     STATE_WAIT_CROSS_ZERO
//         RunPFCLoop_NoPLL_State_WaitCrossZero(controller); // 传递整个 controller
//         break;
//     case STATE_RUN:                                 // 枚举名称从 STATE_RUN 改为 STATE_RUN
//         RunPFCLoop_NoPLL_State_Running(controller); // 传递整个 controller
//         break;
//     default:                                            // 其他状态不处理
//         controller->loop_sm.current_state = STATE_STOP; // 直接更新 current_state
//         break;
//     }
// }

// /*---------- 停止状态处理 ----------*/
// // 参数类型修正，内部访问 loop_sm 和 param
// static inline void RunPFCLoop_NoPLL_State_Stop(InterruptController *controller)
// {
//     switch (controller->loop_sm.event) // 访问 loop_sm.event
//     {
//     case EVENT_LOOP_NONE: // 无事件
//         /*用户处理*/
//         controller->pwm.pwm_en_flag = Nonactivated; // 不允许PWM
//         Loop_Init(&controller->param);
//         /*状态切换*/
//         controller->loop_sm.current_state = STATE_IDLE; // 直接更新 current_state
//         break;
//     case EVENT_LOOP_STOP: // 停止事件
//         /*用户处理*/
//         controller->pwm.pwm_en_flag = Nonactivated; // 不允许PWM
//         Loop_Init(&controller->param);              // 初始化环路参数
//         /*状态切换*/
//         controller->loop_sm.current_state = STATE_IDLE; // 直接更新 current_state
//         break;
//     default:                                            // 其他事件不响应
//         controller->loop_sm.current_state = STATE_STOP; // 直接更新 current_state
//         break;
//     }
// }
// // 空闲状态处理 (参数类型修正，内部访问 loop_sm)
// static inline void RunPFCLoop_NoPLL_State_Idle(InterruptController *controller)
// {
//     switch (controller->loop_sm.event) // 访问 loop_sm.event
//     {
//     case EVENT_LOOP_ENABLE: // 环路开始事件
//         /*用户处理*/
//         /*状态切换条件*/
//         controller->loop_sm.current_state = STATE_WAIT_CROSS_ZERO; // 直接更新 current_state
//         break;
//     case EVENT_LOOP_STOP: // 停止事件
//         /*用户处理*/
//         /*状态切换条件*/
//         controller->loop_sm.current_state = STATE_STOP; // 直接更新 current_state
//         break;
//     case EVENT_LOOP_NONE: // 无事件
//         /*用户处理*/
//         /*状态切换*/
//         controller->loop_sm.current_state = STATE_IDLE; // 直接更新 current_state
//         break;
//     default:                                            // 其他事件不响应
//         controller->loop_sm.current_state = STATE_STOP; // 直接更新 current_state
//         break;
//     }
// }

// // 等待过零点状态处理 (参数类型修正，内部访问 controller->param 和 controller->loop_sm)
// static inline void RunPFCLoop_NoPLL_State_WaitCrossZero(InterruptController *controller)
// {
//     switch (controller->loop_sm.event) // 访问 loop_sm.event
//     {
//     case EVENT_LOOP_STOP: // 停止事件
//         /*用户处理*/
//         /*状态切换*/
//         controller->loop_sm.current_state = STATE_STOP; // 直接更新 current_state
//         break;
//     case EVENT_LOOP_NONE:                                    // 无事件
//                                                              /*用户处理*/
//         if (controller->param.SignalAnalysisr->Vrms > 12.0f) // 有效值大于10V
//         {
//             if (controller->param.vo_actual < 0.5f)
//             {
//                 LL_HRTIM_TIM_SetCompare1(HRTIM1, controller->pwm.timer[0], 0);
//                 LL_HRTIM_TIM_SetCompare1(HRTIM1, controller->pwm.timer[1], 0);
//                 // 这里需要设置PWM的初始状态，初始状态不对会炸机
//                 controller->loop_sm.current_state = STATE_RUN; // 直接更新 current_state
//                 break;
//             }
//         }
//         else // 有效值不满足
//         {
//             controller->loop_sm.current_state = STATE_STOP; // 返回
//             break;
//         }
//         /*默认转移判断*/
//         controller->loop_sm.current_state = STATE_WAIT_CROSS_ZERO; // 默认切换到等待锁相状态
//         break;
//     default:                                            // 其他事件不响应
//         controller->loop_sm.current_state = STATE_STOP; // 直接更新 current_state
//         break;
//     }
// }

// /*---------- 运行状态处理 ----------*/
// // 运行状态处理 (参数类型修正，内部访问 controller->param 和 controller->loop_sm)
// static inline void RunPFCLoop_NoPLL_State_Running(InterruptController *controller)
// {
//     switch (controller->loop_sm.event) // 访问 loop_sm.event
//     {
//     case EVENT_LOOP_STOP: // 停止事件
//         /*用户处理*/
//         controller->pwm.pwm_en_flag = Nonactivated; // 不允许PWM
//         /*状态切换*/
//         controller->loop_sm.current_state = STATE_STOP; // 直接更新 current_state
//         break;
//     case EVENT_LOOP_NONE: // 无事件
//                           /*用户处理*/
//         // if (controller->param.SignalAnalysisr->Vrms < 12.0f) // DQ范围规定
//         // {
//         //     controller->pwm.pwm_en_flag = Nonactivated;     // 不允许PWM
//         //     Loop_Init(&controller->param);                  // 初始化
//         //     controller->loop_sm.current_state = STATE_STOP; // 返回空闲状态
//         //     break;
//         // }

//         //
//         变步长还是有用的，优点：在你强制电流换向时提供过度点，防止变化过快炸机，缺点：会在启动时存在一个小的电流跌落
//         // 这里PI要加个负号
//         VariableStep_Update_Inline(controller->param.udcref, controller->param.udc_ref);
//         float temp = -Increasing_PI_Control_Inline(controller->param.pi_udc, controller->param.udc_ref,
//                                                    controller->param.trap_udc->notch.Yn) *
//                      (controller->param.SignalAnalysisr->phaseshifter_output /
//                      controller->param.SignalAnalysisr->Vrms);
//         // 计算PWM调制波形  ,如果使用前馈记得把PR计算的1.0f限幅去掉
//         controller->pwm.mod_wave =
//             (PRdiff_Calculate_Inline(controller->param.pr_i[0], temp, controller->param.il_actual) +
//              controller->param.vo_actual) /
//             controller->param.trap_udc->notch.Yn;

//         controller->pwm.pwm_en_flag = Activated; // 允许PWM
//         /*默认转移*/
//         controller->loop_sm.current_state = STATE_RUN; // 直接更新 current_state
//         break;
//     default:                                            // 其他事件不响应
//         controller->loop_sm.current_state = STATE_STOP; // 直接更新 current_state
//         break;
//     }
// }
#endif /* INC_STATE_MACHINE_H_ */
